Over the past decade or so a paradigm has developed governing how complex software including, for example, operating systems and application suites, will be updated. Typically, an operating system or application suite is released (“goes gold”) and is assigned one or both of a new name and a version number. Users of the operating system or application suite then typically find software faults (“bugs”), a number of which always seem to survive pre-release testing. Those responsible for the operating system or application suite then release a series of so-called “patches” which eliminate bugs found in the software. For a particularly complex computer program many such patches may be released.
Patching activity frequently occurs in parallel with identification of new and/or enhanced features desired by users of the operating system or application suite, or that are rendered necessary or even mandatory by technological developments. After enough enhancements are identified, developed and beta-tested, the improved operating system or application suite is released as a new product. So a pattern develops of new release, followed by patching activity, followed by new release, followed by patching activity, . . . etc.
When presented with the availability of a new release, users decide whether new features included in the new software release are needed. If not, the user will not acquire the new release. Often, the situation is more complicated, with potential users holding back until first adopters report their experiences with the new release. If a consensus is reached in a user community that features of the new release outweigh drawbacks of the new release (such as, for example, unnecessary modifications to user interfaces which need to be learned; slowdown in overall performance due to increased code size; or overall “buggy” performance of a heretofore stable program), then those potential users holding back will purchase the new release.
The same concerns are reflected in decisions about whether to adopt new patches as they become available. Most user populations are aware of so-called “horror stories” that accompany the reflexive and unthinking adoption of any and all software patches. For example, an application suite which previously operated in a responsive mariner may now function in a less-responsive manner due to a resource-intensive software patch. In other situations, the software patch may result in instability—“crashes”—when code associated with the patch is executed. It is not unusual for some users to have the feeling that they have become unwitting members in a beta testing program for the patch.
Such outcomes are particularly troubling when users realize after-the-fact that the applied patch concerned “improvements” to functionality that they may rarely, or never, use. It is well-known in the art of computer software that particular users will rarely employ all of the functionality of a software system. Rather, the full functionality of a software system is required in order to address a cross-section of needs reflected in a target market. Accordingly, it is often the case that a patch may fix a problem in functionality that is seldom, or never, used by a particular user.
When viewed from the perspective of a large corporation, reflexive and unthinking patching activity may result in numerous inefficiencies when the activities associated with adopting a patch are aggregated across a corporation. A given patch consumes resources in several ways: it may take network bandwidth to download, storage space to store and computational cycles to install. Often more importantly, the time and energy of a system user may be needed to decide whether to install the patch and, if the user decides to do so, to direct installation of the patch. Decisions about the advisability of installing a patch may depend on information which is not in the user's possession, requiring the user to search for the information. The patch, when installed, may reduce the performance of the software system, resulting in many users undoing the patch thereby incurring further inefficiencies.
Thus, those skilled in the art desire improved methods and apparatus for controlling software patching activities. In particular, those skilled in the art desire methods and apparatus for implementing control over patching activities. Further, those skilled in the art desire methods and apparatus for providing software functionality capable of performing software patching activity in accordance with decisions made about when to patch.